package com.example.VisualPassGuard;

import android.app.Activity;
import android.content.Context;
import android.graphics.*;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.util.FloatMath;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.ImageView;
import android.widget.ZoomControls;

import java.util.ArrayList;
import java.util.Random;

public class ZoomInZoomOut extends Activity {
    private static final String TAG = Run.LOG_TAG;
    @SuppressWarnings("unused")
    private static final float MIN_ZOOM = 1f, MAX_ZOOM = 1f;

    // These matrices will be used to scale points of the image
    Matrix matrix = new Matrix();
    Matrix savedMatrix = new Matrix();

    // The 3 states (events) which the user is trying to perform
    static final int NONE = 0;
    static final int DRAG = 1;
    static final int ZOOM = 2;
    int mode = NONE;

    // these PointF objects are used to record the point(s) the user is touching
    PointF start = new PointF();
    PointF mid = new PointF();
    float oldDist = 1f;

    float currentZoomFactor = 1.0f;

    ZoomControls btnZoomControls;
    ImageView imageView;


    ArrayList<Rect> allTextRect = new ArrayList<Rect>();

    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.zoom_image);

        imageView = (ImageView) findViewById(R.id.zoom_imageView);
//        imageView.setImageDrawable(getResources().getDrawable(R.drawable.wallpaper_1));
        //imageView.setOnTouchListener(this);
        imageView.setOnTouchListener(new ImageViewOnTouchListener());


        /*Bitmap mBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.wallpaper_1_small);
        Canvas g = new Canvas(mBitmap);
        Paint p = new Paint();
        p.setColor(Color.BLACK);
        p.setAntiAlias(true);
        g.drawText("MY SIMPLE Text", 10, 10, p);

        imageView.setImageDrawable(new BitmapDrawable(mBitmap));*/

        imageView.setImageDrawable(writeTextOnDrawable(R.drawable.wallpaper_1_small, "MY SIMPLE Text"));


        for (int i=0; i<200; i++) {
            //Bitmap bitmap = ((BitmapDrawable) imageView.getDrawable()).getBitmap();
            Bitmap bitmap = drawableToBitmap(imageView.getDrawable());
            BitmapDrawable bitmapDrawable = writeTextOnBitmap(bitmap, "Text " + i);
            if (bitmapDrawable == null) continue;
            imageView.setImageDrawable(bitmapDrawable);
        }
        //Bitmap = imageView.get

        btnZoomControls = (ZoomControls) findViewById(R.id.zoomControls);
        btnZoomControls.setOnZoomInClickListener(new View.OnClickListener() {public void onClick(View v) {
            imageView.setScaleType(ImageView.ScaleType.MATRIX);

            currentZoomFactor = currentZoomFactor + 0.1f;

            Matrix myMatrix = new Matrix();
            myMatrix.postScale(currentZoomFactor, currentZoomFactor);
            imageView.setImageMatrix(myMatrix);

        }});
        btnZoomControls.setOnZoomOutClickListener(new View.OnClickListener() {public void onClick(View v) {
            imageView.setScaleType(ImageView.ScaleType.MATRIX);

            currentZoomFactor = currentZoomFactor - 0.1f;

            Matrix myMatrix = new Matrix();
            myMatrix.postScale(currentZoomFactor, currentZoomFactor);
            imageView.setImageMatrix(myMatrix);
            //setZoomOut();
        }});
    }

    private class ImageViewOnTouchListener implements OnTouchListener {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            ImageView view = (ImageView) v;
            view.setScaleType(ImageView.ScaleType.MATRIX);
            float scale;

            dumpEvent(event);
            // Handle touch events here...

            switch (event.getAction() & MotionEvent.ACTION_MASK) {
                case MotionEvent.ACTION_DOWN:   // first finger down only
                    savedMatrix.set(matrix);
                    start.set(event.getX(), event.getY());
                    Log.d(TAG, "mode=DRAG"); // write to LogCat
                    mode = DRAG;
                    break;

                case MotionEvent.ACTION_UP: // first finger lifted

               /* case MotionEvent.ACTION_POINTER_UP: // second finger lifted

                    mode = NONE;
                    Log.d(TAG, "mode=NONE");
                    break;

                case MotionEvent.ACTION_POINTER_DOWN: // first and second finger down

                    oldDist = spacing(event);
                    Log.d(TAG, "oldDist=" + oldDist);
                    if (oldDist > 5f) {
                        savedMatrix.set(matrix);
                        midPoint(mid, event);
                        mode = ZOOM;
                        Log.d(TAG, "mode=ZOOM");
                    }
                    break;
*/
                case MotionEvent.ACTION_MOVE:

                    if (mode == DRAG) {
                        matrix.set(savedMatrix);
                        matrix.postTranslate(event.getX() - start.x, event.getY() - start.y); // create the transformation in the matrix  of points
                    } else if (mode == ZOOM) {
                       /* // pinch zooming
                        float newDist = spacing(event);
                        Log.d(TAG, "newDist=" + newDist);
                        if (newDist > 5f) {
                            matrix.set(savedMatrix);
                            scale = newDist / oldDist; // setting the scaling of the
                            // matrix...if scale > 1 means
                            // zoom in...if scale < 1 means
                            // zoom out

                            if (scale > 1) {
                                currentZoomFactor = currentZoomFactor + 0.1f;
                            } else {
                                currentZoomFactor = currentZoomFactor - 0.1f;
                            }

                            matrix.postScale(currentZoomFactor, currentZoomFactor);//, mid.x, mid.y);
                        }*/
                    }
                    break;
            }

            view.setImageMatrix(matrix); // display the transformation on screen

            return true; // indicate event was handled
        }
    }



    private BitmapDrawable writeTextOnDrawable(int drawableId, String text) {

        Bitmap bm = BitmapFactory.decodeResource(getResources(), drawableId)
                .copy(Bitmap.Config.ARGB_8888, true);

        Typeface tf = Typeface.create("Helvetica", Typeface.BOLD);

        Paint paint = new Paint();
        paint.setStyle(Paint.Style.FILL);
        paint.setColor(Color.argb(50, 0,0,0));
        paint.setTypeface(tf);
        paint.setTextAlign(Paint.Align.CENTER);
        paint.setTextSize(convertToPixels(11));

        Rect textRect = new Rect();
        paint.getTextBounds(text, 0, text.length(), textRect);

        Canvas canvas = new Canvas(bm);

        //If the text is bigger than the canvas , reduce the font size
        if(textRect.width() >= (canvas.getWidth() - 4))     //the padding on either sides is considered as 4, so as to appropriately fit in the text
            paint.setTextSize(convertToPixels(7));        //Scaling needs to be used for different dpi's

        //Calculate the positions
        int xPos = (canvas.getWidth() / 2) - 2;     //-2 is for regulating the x position offset

        //"- ((paint.descent() + paint.ascent()) / 2)" is the distance from the baseline to the center.
        int yPos = (int) ((canvas.getHeight() / 2) - ((paint.descent() + paint.ascent()) / 2)) ;

        canvas.drawText(text, xPos, yPos, paint);

        return new BitmapDrawable(getResources(), bm);
    }


    private BitmapDrawable writeTextOnBitmap(Bitmap bm, String text) {
/*
        Bitmap bm = BitmapFactory.decodeResource(getResources(), drawableId)
                .copy(Bitmap.Config.ARGB_8888, true);*/
        Random random = new Random();

        Typeface tf = Typeface.create("Helvetica", Typeface.BOLD);

        Paint paint = new Paint();
        paint.setStyle(Paint.Style.FILL);

        int r = random.nextInt(150);
        int g = random.nextInt(150);
        int b = random.nextInt(150);
        int alpha = 40 + random.nextInt(40);
        paint.setColor(Color.argb(alpha, r,g,b));
        paint.setTypeface(tf);
        paint.setTextAlign(Paint.Align.CENTER);

        int size = 10 + random.nextInt(1);
        paint.setTextSize(size);
        //paint.setTextSize(convertToPixels(size));

        Rect textRect = new Rect();
        paint.getTextBounds(text, 0, text.length(), textRect);

        Canvas canvas = new Canvas(bm);

        //If the text is bigger than the canvas , reduce the font size
       /* if(textRect.width() >= (canvas.getWidth() - 4))     //the padding on either sides is considered as 4, so as to appropriately fit in the text
            paint.setTextSize(convertToPixels(7));        //Scaling needs to be used for different dpi's
*/
      /*  //Calculate the positions
        int xPos = (canvas.getWidth() / 2) - 2;     //-2 is for regulating the x position offset

        //"- ((paint.descent() + paint.ascent()) / 2)" is the distance from the baseline to the center.
        int yPos = (int) ((canvas.getHeight() / 2) - ((paint.descent() + paint.ascent()) / 2)) ;*/


        int xPos = random.nextInt(canvas.getWidth()-20) + 10;
        int yPos = random.nextInt(canvas.getHeight()-20) + 10;

        textRect.offsetTo(xPos, yPos);
        textRect = expandRect(textRect, 10);

        Log.i(Run.LOG_TAG, "rect=" + textRect);

        Log.i(Run.LOG_TAG, "canvas.getWidth() " + canvas.getWidth()+ "; canvas.getHeight() " + canvas.getHeight());

        if (!isRectCrossAllRect(textRect)) {
            canvas.drawText(text, xPos, yPos, paint);
            allTextRect.add(textRect);
            Log.i(Run.LOG_TAG, "text added");

        } else {
            Log.i(Run.LOG_TAG, "text NOT added");

        }



        return new BitmapDrawable(getResources(), bm);
    }

    private Rect expandRect(Rect oldRect, int radius) {
        Rect newRect = new Rect(oldRect);
        newRect.left = newRect.left - radius;
        newRect.top = newRect.top - radius;
        newRect.right = newRect.right + radius;
        newRect.bottom = newRect.bottom + radius;

        return newRect;
    }

    private boolean isRectCrossAllRect(Rect newRect) {
        for (Rect currentRect: allTextRect) {
           if (Rect.intersects(newRect, currentRect)) {
               return true;
           }
        }

        return false;
    }



    public int convertToPixels(int nDP)
    {
        final float conversionScale = getBaseContext().getResources().getDisplayMetrics().density;

        return (int) ((nDP * conversionScale) + 0.5f) ;

    }


    public static Bitmap drawableToBitmap (Drawable drawable) {
        if (drawable instanceof BitmapDrawable) {
            return ((BitmapDrawable)drawable).getBitmap();
        }

        Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
        drawable.draw(canvas);

        return bitmap;
    }


    /*
     * --------------------------------------------------------------------------
     * Method: spacing Parameters: MotionEvent Returns: float Description:
     * checks the spacing between the two fingers on touch
     * ----------------------------------------------------
     */
    private float spacing(MotionEvent event) {
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return FloatMath.sqrt(x * x + y * y);
    }

    /*
     * --------------------------------------------------------------------------
     * Method: midPoint Parameters: PointF object, MotionEvent Returns: void
     * Description: calculates the midpoint between the two fingers
     * ------------------------------------------------------------
     */
    private void midPoint(PointF point, MotionEvent event) {
        float x = event.getX(0) + event.getX(1);
        float y = event.getY(0) + event.getY(1);
        point.set(x / 2, y / 2);
    }

    /**
     * Show an event in the LogCat imageView, for debugging
     */
    private void dumpEvent(MotionEvent event) {
        String names[] = {"DOWN", "UP", "MOVE", "CANCEL", "OUTSIDE", "POINTER_DOWN", "POINTER_UP", "7?", "8?", "9?"};
        StringBuilder sb = new StringBuilder();
        int action = event.getAction();
        int actionCode = action & MotionEvent.ACTION_MASK;
        sb.append("event ACTION_").append(names[actionCode]);

        if (actionCode == MotionEvent.ACTION_POINTER_DOWN || actionCode == MotionEvent.ACTION_POINTER_UP) {
            sb.append("(pid ").append(action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
            sb.append(")");
        }

        sb.append("[");
        for (int i = 0; i < event.getPointerCount(); i++) {
            sb.append("#").append(i);
            sb.append("(pid ").append(event.getPointerId(i));
            sb.append(")=").append((int) event.getX(i));
            sb.append(",").append((int) event.getY(i));
            if (i + 1 < event.getPointerCount())
                sb.append(";");
        }

        sb.append("]");
        Log.d("Touch Events ---------", sb.toString());
    }
}